import jdk.swing.interop.SwingInterOpUtils;

/**
 * Created with IntelliJ IDEA.
 * Description: Daily Study
 * User: Lenovo
 * Date: 2024-07-07
 * Time: 8:44
 */
public class Test {
    public static void main(String[] args) {
        String str = "100";
        int num = Integer.parseInt(str);
    }
    public static void main18(String[] args) {
        int num = 10;
        //方法一
        String str1 = num+"";
        //方法二
        String str2 = String.valueOf(num);
    }
    public static void main17(String[] args) {
        String s1 = "Hello";
        String s2 = "world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2);//s1+s2表示：将s1和s2进行拼接
    }
    public static void main16(String[] args) {
        byte a = 10;
        byte b = 20;
        byte c = (byte) (a + b);
        System.out.println(c);
    }
    public static void main15(String[] args) {
        byte a = 10;
        byte b = 20;
//        byte c = a + b;

    }
    public static void main14(String[] args) {
        int a =10;
        long b = 20;
//        int c = a + b;
        long d = a + b;
//        System.out.println(c);
    }
    public static void main13(String[] args) {
        int a = 10;
        long b = 100L;
        b = a;  //int-->long,数据范围由小到大，隐式转换
        a = (int)b;  //long-->int,数据范围由大到小，需要强转，否则编译失败

        float f =3.14f;
        double d = 5.12;
        d = f;  //float-->double，数据范围由小到大，隐式转换
        f = (float) d;  //double-->float,数据范围由大到小，需要强转，否则编译失败

//        a = d;  //报错，类型不兼容
        a = (int)d;  //int没有double表示的范围大，需要强转，小数点后全部丢弃

        byte b1 = 100;  //100默认为int, 没有超过byte范围，隐式转换
        byte b2 = (byte)257;  //257默认为int，超过byte范围，需要显式转换，否则报错

        boolean flag = true;
//        a = flag;  //编译失败：类型不兼容
//        flag = a;  //编译失败：类型不兼容
    }
    public static void main12(String[] args) {
        System.out.println(1024); //整形默认情况下是int
        System.out.println(3.14); //浮点型默认情况下是double

        int a = 100;
        long b = 10L;
        b = a; //a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
        //a = b; //编译报错，long的范围比int范围大，会有数据丢失，不安全

        float f = 3.14f;
        double d = 5.12;
        d = f; //编译器会将f转换为double，然后进行赋值
        //f = d; //double表示数据范围大，直接将float交给double会有数据丢失，不安全

        byte b1 = 100; //编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        //byte b2 = 257; //编译失败，257超过了byte的数据范围，有数据丢失
    }

    public static void main11(String[] args) {
        boolean b = true;
        System.out.println(b);

        b = false;
        System.out.println(b);
    }

    public static void main10(String[] args) {
        char c1 = 'A'; //大写字母
        char c2 = '1'; //数字字符

        System.out.println(c1);
        System.out.println(c2);

        //注意：Java中的字符可以存放整形
        char c3 = '帅';
        System.out.println(c3);
    }
    public static void main9(String[] args) {
        float num = 1.0f;
        float num2 = 1.0F;
        System.out.println(num);
        System.out.println(num2);
    }

    public static void main8(String[] args) {
        double d = 3.14;
        System.out.println(d);

        int a = 1;
        int b = 2;
        System.out.println(a/b);

        double c = 1.0;
        double e = 2.0;
        System.out.println(c/e);

        double num = 1.1;
        System.out.println(num*num);
    }
    public static void main7(String[] args) {
        byte b = 10;
        System.out.println(b);

        //byte型变量所能表示的范围：
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
    }

    public static void main6(String[] args) {
        short a = 10;
        System.out.println(a);

        //short型变量所能表示的范围：
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
    }

    public static void main5(String[] args) {
        int a = 10;
        long b = 10; //long定义的长整型变量

        long c = 10L; //为了区分int和long类型，一般建议：long类型变量的初始值之后加l或者L
        long d = 10l; //一般更加以加大写L，因为小写l与1不好区分

        //long型变量所能表示的范围：这个数据范围远超过int的表示范围，足够绝大部分的工程场景使用
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
    }


    public static void main4(String[] args) {
        //方式一：在定义时给出初始值
        int a = 10;
        System.out.println(a);

        //方式二：在定义时没有给初始值，但使用前必须设置初值
        int b;
        b = 10;
        System.out.println(b);

        //使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
//        int c;
//        System.out.println(c);
//        c = 100;

        //int型变量所能表示的范围：
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

//        //注意：在定义int型变量时，所赋值不能超过int的范围
//        int d = 12345678901234;//编译报错，初值超过了int的范围
    }

    public static void main3(String[] args) {
        int a = 10;
        double d =3.14;
        char c = 'A';
        boolean b = true;

        System.out.println(a);
        System.out.println(d);
        System.out.println(c);
        System.out.println(b);

        a = 100;  //a是变量，a中的值是可以修改的，注意：=在Java中表示赋值，即：将100交给a，a中保存的值就是100
        System.out.println(a);

        //注意：在一行可以定义多个相同类型的变量
        int a1 = 10,a2 = 20,a3 = 30;
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
    }

    public static void main2(String[] args) {
        System.out.println("Hello world");
        System.out.println(100);
        System.out.println(3.14);
        System.out.println('A');
        System.out.println(true);
        System.out.println(false);
    }
    public static void main1(String[] args) {
        int a = 3;
//        byte b = a;
        System.out.println(a);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}
